home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume3 / uumail2 < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  59.7 KB
  1. From: Stan Barber <genrad!neuro1!sob>
  2. Subject: uumail release 2
  3. Reply-To: sob@neuro1.UUCP (Stan Barber)
  4. Newsgroups: mod.sources
  5. Approved: jpn@panda.UUCP
  6.  
  7. Mod.sources:  Volume 3, Issue 68
  8. Submitted by: Stan Barber <genrad!neuro1!sob>
  9.  
  10.  
  11. This version of uumail contains all the fixes reported since
  12. the last release. Thanks to those that reported problems and
  13. especially those that sent along fixes or improvements.
  14.  
  15. This version also contains some improvements that I saw in
  16. the GATech Sendmail Configuration version of uumail to help
  17. uumail "know" when the database is being rebuilt. Please 
  18. be sure to read the README >ESPECIALLY IF YOU RUN A 
  19. DBM-formated database< ....
  20.  
  21. The next version of uumail will contain some more options
  22. to allow header munging and path optimization (I hope).
  23. If you already have some ideas or code that you'd like to
  24. donate to the cause, send it along.
  25.  
  26. Have a good holiday, or if this comes out in 1986, Have
  27. a good year.
  28.  
  29. #! /bin/sh
  30. # This is a shell archive, meaning:
  31. # 1. Remove everything above the #! /bin/sh line.
  32. # 2. Save the resulting text in a file.
  33. # 3. Execute the file with /bin/sh (not csh) to create the files:
  34. #    README
  35. #    makefile
  36. #    domains
  37. #    palias
  38. #    address.1
  39. #    address.c
  40. #    gethostnam.c
  41. #    getpath.c
  42. #    opath.3
  43. #    opath.c
  44. #    rmail.c
  45. #    uuconf.h
  46. #    uumail.1
  47. #    uumail.c
  48. #    uupath.1
  49. #    uupath.c
  50. # This archive created: Tue Dec 24 09:31:18 1985
  51. export PATH; PATH=/bin:$PATH
  52. echo shar: extracting "'README'" '(4023 characters)'
  53. if test -f 'README'
  54. then
  55.     echo shar: will not over-write existing file "'README'"
  56. else
  57. cat << \SHAR_EOF > 'README'
  58. This is an updated version of uumail (and uupath) that can 
  59. access a pathalias-generated database to facilitate routine mail.
  60.  
  61. These program can cope with DBM and standard line-oriented forms of 
  62. pathalias-generated databases.
  63.  
  64. This version of uumail can be used as uupath by linking uumail to
  65. uupath. Also, this version can handle domain addresses (user@host.domain).
  66. You can put as many addresses on a line as you like.
  67.  
  68. This version fixes a few bugs in the previous release. Some additional 
  69. functionality and robustness are added as well. The bugs included 
  70. lack of initilization of some variables in address.c, inconsistant calling
  71. of getpath in uumail, address and opath, and failure to handle % in addresses
  72. correctly. Additional features include  the ability of getpath to detect when
  73. the database is being updated and wait or abort as necessary, the ability to 
  74. retry accessing the database when it will not open (as might be the case when
  75. updating it), the ability (if the database is sorted) to search a plain-text
  76. database much faster.
  77.  
  78.  *    IF YOU ARE USING A DBM DATABASE, READ THIS!
  79.  *    If the special sentinel value of @@@ is not present in the
  80.  *    database, then getpath will assumed that the database is being
  81.  *    rebuilt and will block for TIMEOUT (default = 180) seconds.  
  82.  *    If, after 5 such blocks, the sentinel is not present,
  83.  *    the error code EX_TEMPFAIL is returned.
  84.  *    The same is true if the dbm files cannot be initialized.
  85.  *    Please be sure to add the sentinal to the DBM database when
  86.  *    it is created.
  87.  *
  88.  
  89. There are some compile flags to be aware of when making uumail.
  90. Here is a list of them.
  91.  
  92. DEBUG compiles in the debugging code.
  93. OPATH causes the opath subroutine to be used to resolve addresses.
  94. If you do not use this flag, you cannot use the user@host.domain style
  95. addresses with uumail.
  96. DBM causes uumail to use the DBM format patalias database. If you do not
  97. have the dbm libraries, do not use this flag.
  98. SYSIII will make adjustments for system that are derived from UNIX System
  99. III or System V.
  100. NOGRADE should be used if your uux does not understand the -g flag.
  101. NORETURN should be used if your uux does not understand the -a flag.
  102. LOG will enable logging of uumail traffic.
  103. UGLYUUCP causes the From_ line produced by uumail to contain the
  104. "remote from hostname" string.
  105. GETHOSTNAME will cause the system call gethostname to be used. If you
  106. are a BSD site, define this.
  107. SYSTEMNAME will cause the systemname to be derived from the file
  108. /usr/lib/uucp/SYSTEMNAME. This should be defined if your machine
  109. is a Sperry 5000.
  110. SORTED will cause the non-DBM database to be searched fasted, BUT
  111. it assumes that this database is SORTED. If you do not sort your
  112. database, do not define this.
  113.  
  114. If you want to install this system, use "make install". If you want
  115. to have it do all the work for incoming mail, type "make mailer". You
  116. probably do not want to "make mailer" if you run sendmail.
  117.  
  118. Here is the mailer segment of a sendmail configuration file that you
  119. can use to define the uumail program as a mailer.
  120. -------------------------------------------------------------------
  121. ############################################################
  122. #### This is a special mailer that takes advantage of    ###
  123. #### usemap database for addresses to UUCP sites         ###
  124. ############################################################
  125.  
  126. Muumail, P=/usr/lib/uucp/uumail,F=sDFhuUM,S=13,R=23,M=1000000,
  127.     A=uumail -h -gC -f$g $h!$u
  128. --------------------------------------------------------------
  129. Please be sure that the S= and R= rules are correct for your
  130. system. They should match the uucp mailer rules exactly.
  131.  
  132. A manual page for address, opath, uumail and uupath are included.
  133.  
  134. Please forward comments and bug fixes to me at sob@rice.edu or 
  135. ihnp4!shell!neuro1!sob or texsun!drilltech!sob
  136.  
  137. Stan Barber
  138. Baylor College of Medicine
  139. Houston, Texas
  140.  
  141. P.S. My thanks to all those who reported bugs from the previous release.
  142. Please continue to send them in, and I will try to keep fixing them.
  143. SHAR_EOF
  144. if test 4023 -ne "`wc -c < 'README'`"
  145. then
  146.     echo shar: error transmitting "'README'" '(should have been 4023 characters)'
  147. fi
  148. fi
  149. echo shar: extracting "'makefile'" '(3265 characters)'
  150. if test -f 'makefile'
  151. then
  152.     echo shar: will not over-write existing file "'makefile'"
  153. else
  154. cat << \SHAR_EOF > 'makefile'
  155. ####################################################################
  156. # makefile for uumail & uupath
  157. # program to integrate with pathalias created uucpmap databases
  158. # programs originally developed by Jeff Donnelly
  159. # updated to use pathalias database by Stan Barber
  160. # $Header: makefile,v 1.4 85/12/10 20:40:45 sob Exp $
  161. #
  162. # the following defines should be configured for you site
  163. # add -DDBM to CCFLAGS if your pathalias database used the
  164. # dbm(3) routines
  165. # if you are a ATT system III or system V site
  166. # or a masscomp add the -DSYSIII flags
  167. # If you want to use the opath subroutine to deal with
  168. # domain names add the -DOPATH flag to the CFLAGS line
  169. # you may want to modify the LIBS line to correspond to 
  170. # libraries that you may need at you site
  171. # see conf.h for other changes that may need be made
  172. # If you DO NOT use a DBM formatted database and would like to
  173. # get the best possible speed from uumail, add the -DSORTED
  174. # flag and be sure to sort your database
  175. # IMPORTANT INFORMATION ABOUT UUCP
  176. # If your uucp does not understand the -g (grade) flag
  177. # add the -DNOGRADE flag to CFLAGS.
  178. # If your uucp does not know about the -a (returnto) flag
  179. # add the -DNORETURN flag to CFLAGS
  180. # $Log:    makefile,v $
  181. # Revision 1.4  85/12/10  20:40:45  sob
  182. # Added install, mailer and all make options. Also defined BINDIR, UUCPDIR
  183. # and other useful things
  184. # 
  185. # Revision 1.3  85/08/03  00:38:33  UUCP
  186. # Added support for shar and RCS.
  187. # Changed name of gethostname to gethostnam to allow RCS to work right.
  188. # Stan Barber
  189. # 
  190. # Revision 1.2  85/07/11  19:28:52  sob
  191. # updated with gethostname.c
  192. # 
  193. # Revision 1.1  85/07/11  19:23:22  sob
  194. # Initial revision
  195. # 
  196. ###############################################################
  197. .SUFFIXES: .c,v .h,v
  198.  
  199. CFLAGS= -O -DSYSIII -DDEBUG -DOPATH -DUGLYUUCP -DLOG -DSORTED
  200.  
  201. LIBS=
  202.  
  203. BINDIR=/usr/lbin
  204.  
  205. UUCPDIR=/usr/lib/uucp
  206.  
  207. LIBDIR=/usr/lib
  208.  
  209. .c,v.c:
  210.     co -q $*.c
  211.  
  212. .h,v.h:
  213.     co -q $*.h
  214.  
  215. all: uumail rmail address
  216.  
  217. uumail: getpath.o uumail.o gethostnam.o opath.o
  218.     cc $(CFLAGS) getpath.o uumail.o gethostnam.o opath.o -o uumail $(LIBS)
  219.  
  220. address:address.o opath.o getpath.o
  221.     cc $(CFLAGS) address.o opath.o getpath.o -o address $(LIBS)
  222.  
  223. getpath.o: getpath.c uuconf.h
  224.  
  225. uupath.o: uupath.c uuconf.h
  226.  
  227. uumail.o: uumail.c uuconf.h
  228.  
  229. gethostnam.o:gethostnam.c
  230.  
  231. address.o:address.c
  232.  
  233. opath.o:opath.c
  234.  
  235. rmail: rmail.c gethostnam.o
  236.     cc $(CFLAGS) rmail.c gethostnam.o -o rmail $(LIBS)
  237.  
  238. install: uumail address domains palias
  239.     cp address $(BINDIR)
  240.     cp uumail domains palias $(UUCPDIR)
  241.     @echo "To install rmail in place of the current rmail, type"
  242.     @echo "make mailer"
  243.     ln $(UUCPDIR)/uumail $(BINDIR)/uupath
  244.  
  245. mailer: rmail
  246.     make install
  247.     rm -rf /bin/rmail
  248.     cp rmail /bin/rmail
  249.     
  250.  
  251. lint:
  252.     lint $(CFLAGS) getpath.c uumail.c gethostnam.c opath.c
  253.  
  254. clean: 
  255.     rm -f *.o *.CKP *.BAK *.bak
  256.  
  257. doc: uumail.1 uupath.1 address.1 opath.3
  258.     nroff -man uumail.1 >uumail.cat; nroff -man uupath.1 >uupath.cat; nroff -man address.1 >address.cat; nroff -man opath.3 >opath.cat
  259.  
  260. shar: domains palias rmail.c opath.c address.c uumail.c uuconf.h gethostnam.c uupath.c getpath.c README makefile uumail.1 uupath.1  opath.3 address.1
  261.     shar README domains palias rmail.c opath.c address.c uumail.c uuconf.h gethostnam.c uupath.c getpath.c makefile uumail.1 uupath.1  opath.3 address.1> shar.out
  262.  
  263. SHAR_EOF
  264. if test 3265 -ne "`wc -c < 'makefile'`"
  265. then
  266.     echo shar: error transmitting "'makefile'" '(should have been 3265 characters)'
  267. fi
  268. fi
  269. echo shar: extracting "'domains'" '(1093 characters)'
  270. if test -f 'domains'
  271. then
  272.     echo shar: will not over-write existing file "'domains'"
  273. else
  274. cat << \SHAR_EOF > 'domains'
  275. #
  276. # Domain Table
  277. #
  278. # Format: <domain>,<prefix>,<suffix>,<template>
  279. #
  280. # Where <template> may contain:
  281. #       %P - prefix string
  282. #       %S - suffix string
  283. #       %U - destination user name
  284. #       %N - destination site name
  285. #       %D - destination site name with domain suffix
  286. #       %% - a percent (%) sign
  287. #       %R - pathalias route to the destination site
  288. #
  289. .WA.UUCP,,,%R!%U
  290. .OR.UUCP,,,%R!%U
  291. .N-CA.UUCP,,,%R!%U
  292. .S-CA.UUCP,,,%R!%U
  293. .MTN.UUCP,,,%R!%U
  294. .S-CEN.UUCP,,,%R!%U
  295. .MID-W.UUCP,,,%R!%U
  296. .S-EAST.UUCP,,,%R!%U
  297. .ATL.UUCP,,,%R!%U
  298. .N-ENG.UUCP,,,%R!%U
  299. .HI.UUCP,,,%R!%U
  300. .W-CAN.UUCP,,,%R!%U
  301. .E-CAN.UUCP,,,%R!%U
  302. .EUR.UUCP,,,%R!%U
  303. .UK.UUCP,,,%R!%U
  304. .AUS.UUCP,,,%R!%U
  305. .ISRAEL.UUCP,,,%R!%U
  306. .ATT.UUCP,>ihnp4,,%P!%D!%U
  307. .HP.UUCP,,,%R!%U
  308. .PE.UUCP,,,%R!%U
  309. .UUCP,,,%R!%U
  310. .CSNET,>rice,,%P!%U%%%D@CSNET-RELAY.ARPA
  311. .MAILNET,>rice,,%P!%U%%%D@MULTICS.MIT.EDU
  312. # .BITNET,>rice,,%P!%U%%%D@WISCVM.ARPA
  313. .XEROX,>rice,,%P!%U.%D@XEROX.ARPA
  314. .DEC,>decwrl,,%P!%U@%D
  315. .ARPA,>rice,,%P!%U@%D
  316. .EDU,>rice,,%P!%U@%D
  317. .COM,>rice,,%P!%U@%D
  318. .GOV,>rice,,%P!%U@%D
  319. .MIL,>rice,,%P!%U@%D
  320. .OTH,>rice,,%P!%U@%D
  321. .BITNET,>psuvax,,%P!%U@%D
  322. SHAR_EOF
  323. if test 1093 -ne "`wc -c < 'domains'`"
  324. then
  325.     echo shar: error transmitting "'domains'" '(should have been 1093 characters)'
  326. fi
  327. fi
  328. echo shar: extracting "'palias'" '(151 characters)'
  329. if test -f 'palias'
  330. then
  331.     echo shar: will not over-write existing file "'palias'"
  332. else
  333. cat << \SHAR_EOF > 'palias'
  334. baylor baylor!%s
  335. decwrl shell!ihnp4!decwrl!%s
  336. ihnp4 shell!ihnp4!%s
  337. kitty baylor!kitty!%s
  338. neuro1 %s
  339. psuvax shell!psuvax!%s
  340. rice  rice!%s
  341. shell shell!%s
  342. SHAR_EOF
  343. if test 151 -ne "`wc -c < 'palias'`"
  344. then
  345.     echo shar: error transmitting "'palias'" '(should have been 151 characters)'
  346. fi
  347. fi
  348. echo shar: extracting "'address.1'" '(3589 characters)'
  349. if test -f 'address.1'
  350. then
  351.     echo shar: will not over-write existing file "'address.1'"
  352. else
  353. cat << \SHAR_EOF > 'address.1'
  354. .TH ADDRESS 1 local
  355. .SH NAME
  356. address - display the path generated by \fBdeliver\fR for an
  357. RFC822-format address.
  358. .SH SYNOPSIS
  359. address rfc-address [ ... ]
  360. .SH DESCRIPTION
  361. This program allows you to check the UUCP mail routing path that will
  362. be generated by the UUCP mailer \fBdeliver\fR if you specify an
  363. RFC822-format address \fBrfc-address\fR in the ``To:'' field of the mail header.
  364. For each RFC-style address on the command line, \fBaddress\fR echoes the
  365. address to the standard output, followed by a colon, followed by
  366. the UUCP address that will be used to send the message to that address.
  367.  
  368. .SH "ADDRESS FORMAT"
  369. Briefly, the RFC822-format address is of the form
  370. .nf
  371. .sp 1
  372.     <localaddress>@<hostname>.<network>
  373. .sp 1
  374. .fi
  375. where <hostname> is the name of the system you are sending the message
  376. to, <network> is a modifier for <hostname> identifying the network in
  377. which the address is to be interpreted (UUCP, ARPA, MAILNET, CSNET, etc);
  378. and <localaddress> is an address string to be interpreted on the host
  379. machine.
  380.  
  381. The <localaddress> field may contain further remote addresses to be
  382. interpreted on the host machine.  Typically this will be an address for
  383. mailing via another network; and in particular, the <localaddress> may
  384. (recursively) be identical in format to the RFC address, but with
  385. the symbol `%' replacing the symbol `@' in the standard address format.
  386. Where this form is used, the rightmost % is replaced by an
  387. @ before the host machine sends the message out.
  388.  
  389. On our system, the presently
  390. valid <network>s are UUCP, ARPA, CSNET, and MAILNET.
  391. The recently proposed UUCP domain names are also accepted, although
  392. they are treated the same as plain ``UUCP''.
  393. Omitting
  394. the <network> causes the network to default to UUCP.  The <hostname>
  395. should be the name of a remote machine to which the message is
  396. directed; see \fI/usr/lib/uucp/uuaddress.alpha\fR for a list of all
  397. known UUCP hostnames.  It is \fInot\fR necessary to specify a UUCP pathname
  398. when using this format; the pathname is automatically determined for you
  399. and substituted into the address before mailing.  The selected pathname
  400. is determined using the \fBpathalias\fR database, and is supposed
  401. to be optimal, taking into consideration information provided by
  402. each site about how often they send mail out, etc.
  403.  
  404. .SH EXAMPLES
  405. .HP 5
  406. joe
  407. .br
  408. The message is sent to the user ``joe'' on the local system.
  409. .HP 5
  410. joe@ucbvax
  411. .br
  412. The message is sent to joe on the UUCP system named ``ucbvax''; this
  413. address is automatically translated to a proper (and ostensibly
  414. optimal) UUCP path.
  415. .HP 5
  416. joe@ucbvax.UUCP
  417. .br
  418. Same as joe@ucbvax
  419. .HP 5
  420. joe@ucbvax.ARPA
  421. .br
  422. The message is addressed to joe at ucbvax, using the ARPA network.
  423. The message will be routed to the ARPAnet via a UUCP-ARPAnet gateway.
  424. .HP 5
  425. joe%mit-multics.ARPA@ucbvax
  426. .br
  427. The message is sent to ucbvax, who then uses the address
  428. joe@mit-multics.ARPA to send the message on to mit-multics via the
  429. ARPAnet.  Since ucbvax is on the arpanet, this address will work correctly
  430. (as long as there is someone named joe on the MIT multics machine).
  431. .HP 5
  432. joe%vanderbilt.MAILNET%mit-multics.ARPA@ucbvax
  433. .br
  434. The message is sent via UUCP to ucbvax, who then sends the message
  435. to mit-multics via the arpanet; mit-multics then sends the message
  436. to joe@vanderbilt via MAILNET.  Since the above machines each have access
  437. to the networks named in the address, this address will work correctly.
  438. .SH FILES
  439. /usr/lib/uucp/domains - Domain/gateway table
  440. .br
  441. /usr/lib/uucp/palias - Pathalias database
  442. .SH "SEE ALSO"
  443. opath(3), uupath(1), uumail(8)
  444. .SH AUTHOR
  445. Eric Roskos, CONCURRENT COMPUTERS
  446. SHAR_EOF
  447. if test 3589 -ne "`wc -c < 'address.1'`"
  448. then
  449.     echo shar: error transmitting "'address.1'" '(should have been 3589 characters)'
  450. fi
  451. fi
  452. echo shar: extracting "'address.c'" '(1035 characters)'
  453. if test -f 'address.c'
  454. then
  455.     echo shar: will not over-write existing file "'address.c'"
  456. else
  457. cat << \SHAR_EOF > 'address.c'
  458. /*
  459.  * address - run opath to see what a translated RFC822 address will come
  460.  * out as.
  461.  *
  462.  * By E. Roskos 1/16/85
  463.  * $Log:    address.c,v $
  464.  * Revision 1.3  85/11/24  14:50:01  sob
  465.  * Added corrections provided by regina!mark
  466.  * 
  467.  * Revision 1.2  85/09/16  18:31:53  sob
  468.  * Added DEBUG flag
  469.  * 
  470.  * Revision 1.1  85/09/16  17:50:24  sob
  471.  * Initial revision
  472.  * 
  473.  */
  474. #define _DEFINE
  475. #include "uuconf.h"
  476.  
  477. static char rcsid[] = "$Header: address.c,v 1.3 85/11/24 14:50:01 sob Exp $";
  478.  
  479. EXTERN char *paths;
  480. char *opath();
  481. int Debug;
  482.  
  483. main(argc,argv)
  484. int argc;
  485. char **argv;
  486. {
  487. char *p;
  488. int uswitch;
  489.  
  490. paths = DATABASE;
  491. ConfFile=CONFIGFILE;
  492.  
  493.     if (argc < 2)
  494.     {
  495.         fprintf(stderr,"usage: %s rfcaddress [...]\n",
  496.             argv[0]);
  497.         exit(1);
  498.     }
  499.  
  500.     while (--argc)
  501.     {
  502.         p = *++argv;
  503.         if (*p=='-')
  504.         {
  505.             switch(*++p)
  506.             {
  507.             case 'u': uswitch++;
  508.                   continue;
  509.             case 'd': Debug++;
  510.                       continue;
  511.             default:  printf("unknown switch: %c\n",*p);
  512.                   continue;
  513.             }
  514.             continue;
  515.         }
  516.         printf("%s: %s\n",p,uswitch?oupath(p):opath(p));
  517.     }
  518.  
  519.     exit(0);
  520. }
  521. SHAR_EOF
  522. if test 1035 -ne "`wc -c < 'address.c'`"
  523. then
  524.     echo shar: error transmitting "'address.c'" '(should have been 1035 characters)'
  525. fi
  526. fi
  527. echo shar: extracting "'gethostnam.c'" '(1372 characters)'
  528. if test -f 'gethostnam.c'
  529. then
  530.     echo shar: will not over-write existing file "'gethostnam.c'"
  531. else
  532. cat << \SHAR_EOF > 'gethostnam.c'
  533. #ifndef lint
  534. static char    sccsid[] = "@(#)gethostnam.c    6.1 (down!honey) 85/01/21";
  535. static char    rcsid[] = "$Header: gethostnam.c,v 6.3 85/11/23 05:30:04 UUCP Exp $";
  536. #endif lint
  537.  
  538. #ifndef GETHOSTNAME
  539. #include "uuconf.h"
  540.  
  541. void
  542. gethostname(name, len)
  543. char    *name;
  544. {
  545.     FILE    *whoami, *fopen(), *popen();
  546.     char    *ptr, *index();
  547. #if defined(SYSIII) && !defined(SYSTEMNAME)
  548.     struct utsname utsn;
  549. #endif
  550.  
  551.     *name = '\0';
  552. #ifndef SYSTEMNAME
  553. #ifdef SYSIII
  554.     if (uname(&utsn) != -1)
  555.     {
  556.         strcpy(name,utsn.nodename);
  557.         len = strlen(name);
  558.           return;
  559.     }
  560. #endif
  561. #endif
  562.  
  563. #ifdef SYSTEMNAME
  564.     /* try /usr/lib/uucp/SYSTEMNAME */
  565.     if ((whoami = fopen("/usr/lib/uucp/SYSTEMNAME", "r")) != 0) {
  566.         (void) fgets(name, len, whoami);
  567.         (void) fclose(whoami);
  568.         if ((ptr = index(name, '\n')) != 0)
  569.             *ptr = '\0';
  570.     }
  571.     if (*name)
  572.         return;
  573. #endif
  574.     /* try /usr/include/whoami.h */
  575.     if ((whoami = fopen("/usr/include/whoami.h", "r")) != 0) {
  576.         while (!feof(whoami)) {
  577.             char    buf[100];
  578.  
  579.             if (fgets(buf, 100, whoami) == 0)
  580.                 break;
  581.             if (sscanf(buf, "#define sysname \"%[^\"]\"", name))
  582.                 break;
  583.         }
  584.         (void) fclose(whoami);
  585.         if (*name)
  586.             return;
  587.     }
  588.  
  589.     /* ask uucp */
  590.     if ((whoami = popen("uuname -l", "r")) != 0) {
  591.         (void) fgets(name, len, whoami);
  592.         (void) pclose(whoami);
  593.         if ((ptr = index(name, '\n')) != 0)
  594.             *ptr = '\0';
  595.     }
  596.     if (*name)
  597.         return;
  598.     
  599.     /* failure */
  600.     return;
  601. }
  602. #endif GETHOSTNAME
  603. SHAR_EOF
  604. if test 1372 -ne "`wc -c < 'gethostnam.c'`"
  605. then
  606.     echo shar: error transmitting "'gethostnam.c'" '(should have been 1372 characters)'
  607. fi
  608. fi
  609. echo shar: extracting "'getpath.c'" '(6606 characters)'
  610. if test -f 'getpath.c'
  611. then
  612.     echo shar: will not over-write existing file "'getpath.c'"
  613. else
  614. cat << \SHAR_EOF > 'getpath.c'
  615. /*
  616.  * Name: getpath -- return the full usenet path of the given name
  617.  *
  618.  * Paramaters: sysname (input) -- The system name to be expanded
  619.  *           pathname (output)  The usenet path of the given system name
  620.  *           pathfile (input) the file to search for the system name
  621.  *
  622.  * Returns: EX_OK     -- path found
  623.  *        EX_NOHOST -- path not found
  624.  *        EX_NOINPUT-- unable to open usemap
  625.  *          EX_TEMPFAIL -- database being rebuilt
  626.  *
  627.  * Author: J. Donnelly   3/82
  628.  *
  629.  */
  630.  
  631. /*    IF YOU ARE USING A DBM DATABASE, READ THIS!
  632.  *    If the special sentinel value of @@@ is not present in the
  633.  *    database, then it is assumed that the database is being
  634.  *    rebuilt and the requesting process is blocked for TIMEOUT
  635.  *    (default = 180) seconds.  If, after 5 such blocks, the
  636.  *    sentinel is not present, the error code EX_TEMPFAIL is returned.
  637.  *    The same is true if the dbm files cannot be initialized.
  638.  */
  639.  
  640. /* 22-jun-83 Sheppard
  641.  * modified to rewind path file (if open), rather than open again
  642.  *
  643.  * $Log:    getpath.c,v $
  644.  * Revision 1.14  85/12/13  15:23:21  sob
  645.  * Added patches from umd-cs!steve
  646.  * 
  647.  * Revision 1.13  85/12/10  20:36:58  sob
  648.  * Added modifications suggested in gatech's version of uumail.
  649.  * Now, the DBM version of the database needs to have a SENTINAL in it
  650.  * to indicate that the DATABASE is not being updated. Also added similiar
  651.  * indicators to the non-DBM version to compare modification times and act
  652.  * accordingly. 
  653.  * 
  654.  * Revision 1.12  85/12/02  15:48:39  sob
  655.  * Combined speed hacks and old way of reading database and
  656.  * added compile flag SORTED. If database is SORTED and not DBM, use
  657.  * -DSORTED in CFLAGS to make it fast. If database is not sorted
  658.  * DO NOT use this flag.
  659.  * 
  660.  * Revision 1.11  85/11/24  15:03:41  sob
  661.  * Added changes suggested by regina!mark
  662.  * 
  663.  * Revision 1.10  85/11/24  04:21:45  sob
  664.  * Added efficiency hacks supplied by meccts!asby (Shane P. McCarron)
  665.  * 
  666.  * Revision 1.9  85/11/14  20:21:49  sob
  667.  * Added #ifdef DEBUG to allow compilation without DEBUG
  668.  * 
  669.  * Revision 1.8  85/11/08  03:04:49  sob
  670.  * release version
  671.  * 
  672.  * Revision 1.7  85/09/30  02:47:40  sob
  673.  * Altered to use path filename from global variable.
  674.  * 
  675.  * Revision 1.6  85/08/03  00:48:57  UUCP
  676.  * Cleaned up with lint.
  677.  * Stan Barber
  678.  * 
  679.  * Revision 1.5  85/07/19  17:45:13  UUCP
  680.  * Added \t as a valid seperation character for the database
  681.  * in the non DBM case. This is what pathalias uses.
  682.  * 
  683.  * Revision 1.4  85/07/19  16:44:07  UUCP
  684.  * revised to return proper things in accordance with sysexits
  685.  * Stan
  686.  * 
  687.  * Revision 1.3  85/07/11  19:30:31  sob
  688.  * added "uuconf.h" include file and deleted duplicated information
  689.  * 
  690.  * Revision 1.2  85/07/10  18:30:59  sob
  691.  * updated to add DBM capabilities
  692.  * Stan Barber, Baylor College of Medicine
  693.  * 
  694.  * Revision 1.1  85/07/10  18:03:28  sob
  695.  * Initial revision
  696.  * 
  697.  */
  698.  
  699. #include    "uuconf.h"
  700. #ifndef DBM
  701. #include <sys/types.h>
  702. #include <sys/stat.h>
  703. #endif
  704.  
  705. static char rcsid[] = "$Header: getpath.c,v 1.14 85/12/13 15:23:21 sob Exp $";
  706.  
  707. FILE * fopen (), *in;
  708.  
  709. int getpath (sysname, pathname,pathfile)
  710. char   *sysname, *pathname,*pathfile;
  711. {
  712.     int retval,indx;
  713. #ifdef DBM
  714.     datum lhs,rhs;
  715. #else
  716.     struct stat st;
  717.         time_t modtime;
  718. #ifdef SORTED
  719.     int scomp();
  720.  
  721.     long lo,hi;
  722.     long cur;
  723.     long last;
  724.     static char buf[256];
  725. #else
  726.     char    name[NAMESIZ],*p,t;
  727. #endif
  728. #endif
  729.  
  730. #ifdef DEBUG
  731. if (Debug>2)
  732.     printf("In getpath: Sysname = %s, Pathfile = %s\n",sysname,paths);
  733. #endif
  734.  
  735. #ifdef DBM
  736.     for (indx = 0; indx < 5; indx++)
  737.     {
  738.     if ((retval = dbminit (pathfile)) >= 0)
  739.         break;
  740.     
  741. #ifdef DEBUG
  742.     if (Debug>2)
  743.         fprintf (stderr, "Database unavailable.  Sleeping.\n");
  744. #endif
  745.     sleep (TIMEOUT);
  746.     }
  747.  
  748.     if (retval < 0)
  749.     return(EX_NOINPUT);
  750.  
  751.     lhs.dptr = SENTINEL;
  752.     lhs.dsize = strlen (SENTINEL) + 1;
  753.     for (indx = 0; indx < 5; indx++)
  754.     {
  755.     rhs = fetch (lhs);
  756.     if (rhs.dsize > 0)
  757.         break;
  758.     
  759. #ifdef DEBUG
  760.     if (Debug>2)
  761.         fprintf (stderr, "Database incomplete.  Sleeping.\n");
  762. #endif
  763.     sleep (TIMEOUT);
  764.     }
  765.     if (rhs.dsize <= 0)
  766.     return(EX_TEMPFAIL);
  767.  
  768.         lhs.dptr = sysname;
  769.     lhs.dsize = strlen(sysname)+1;
  770.     rhs = fetch(lhs);
  771.     if (rhs.dptr == NULL) return(EX_NOHOST); /* no name found */
  772.     strcpy(pathname,rhs.dptr);
  773.         return(EX_OK);            /* system name found */
  774.  
  775. #else
  776. if (in == NULL) 
  777.     {
  778.     for (indx = 0; indx < 5; indx++)
  779.         {
  780.         if ((in = fopen(pathfile, "r")) != NULL)
  781.             break;
  782.     
  783. #ifdef DEBUG
  784.         if (Debug>2)
  785.             fprintf (stderr, "Database unavailable.  Sleeping.\n");
  786. #endif
  787.         sleep (TIMEOUT);
  788.         }
  789.     if (in == NULL)
  790.     return(EX_NOINPUT);
  791.     }
  792.     else
  793.     rewind(in);
  794.     indx = 0;
  795. restart:
  796.     indx++;
  797.     if (indx > 5) return(EX_TEMPFAIL);
  798.     stat(pathfile, &st);
  799.     modtime=st.st_mtime; /* original last modification time */
  800.  
  801. #ifdef SORTED
  802.     lo = 0;
  803.     hi = st.st_size;
  804.     last = 0;
  805.     cur = hi >> 1;
  806.  
  807.     while (cur > lo && cur < hi)
  808.     {
  809.         stat(pathfile,&st);
  810.         if (st.st_mtime > modtime) goto restart;
  811.         fseek(in, cur, 0);
  812.         fgets(buf, sizeof(buf), in);
  813.         cur = ftell(in);
  814.         fgets(buf, sizeof(buf), in);
  815.  
  816. #ifdef    DEBUG
  817.     if (Debug > 4)
  818.         printf("Found site %s\n", buf);
  819. #endif
  820.         if (scomp(sysname, buf) < 0) hi = cur;
  821.         else
  822.         if (scomp(sysname, buf) > 0) lo = cur;
  823.         else
  824.         {
  825.             buf[strlen(buf)-1] = '\0';
  826.             strcpy(pathname, (char *)index(buf, '\t') + 1);
  827.             return(EX_OK);
  828.         }
  829.         cur = lo + ((hi - lo)>>1);
  830.         if (last == cur) 
  831.         {
  832.             fseek(in, lo, 0);
  833.             do
  834.             {
  835.                 fgets(buf, sizeof(buf), in);
  836.                 lo = ftell(in);
  837.                 if (scomp(sysname, buf) == 0)
  838.                 {
  839.                     buf[strlen(buf)-1] = '\0';
  840.                     strcpy(pathname, (char *)index(buf, '\t') + 1);
  841.                     return(EX_OK);
  842.                 }
  843.             } while (lo <= hi);
  844.             break;
  845.         } /* end if */
  846.         last = cur;
  847.     } /* end while */
  848.     return(EX_NOHOST);
  849. #else
  850.  
  851.     for (;;)
  852.     {
  853.     p = &name[0];
  854.     while ((t = getc(in)) != EOF && (*p++ = t) != ' ' && t != '\t'); /* read the system name */
  855.         stat(pathfile,&st);
  856.         if (st.st_mtime > modtime) goto restart;        /* database update in progress */
  857.     if( t == EOF) return(EX_NOHOST);
  858.     *--p = '\0';                    /* set end of string */
  859.     p = &name[0];
  860. #ifdef DEBUG
  861.     if (Debug>4) printf("Found %s\n",p);
  862. #endif
  863.     if (strcmp (p,sysname) == 0)
  864.         break;
  865.     while ((getc (in) != '\n'));            /* skip this path */
  866.     }
  867.     p = pathname;                    /* save start loc of pathname */
  868.     while ((*pathname++ = getc (in)) != '\n');
  869.     *--pathname = '\0';
  870.     pathname = p;
  871.     return(EX_OK);            /* system name found */
  872.  
  873. #endif
  874. #endif
  875. }
  876.  
  877. #ifdef    SORTED
  878. #define MAPTAB(c) ((c=='\t')?'\0':c)
  879.  
  880. int scomp(a,b)
  881. char *a,*b;
  882. {
  883. int r;
  884.     while (!(r=(MAPTAB(*a)-MAPTAB(*b))) && *a && *b && *a!='\t' && *b!='\t')
  885.     {
  886.            a++; b++;
  887.     }
  888.     return(r);
  889. }
  890. #endif
  891. SHAR_EOF
  892. if test 6606 -ne "`wc -c < 'getpath.c'`"
  893. then
  894.     echo shar: error transmitting "'getpath.c'" '(should have been 6606 characters)'
  895. fi
  896. fi
  897. echo shar: extracting "'opath.3'" '(4889 characters)'
  898. if test -f 'opath.3'
  899. then
  900.     echo shar: will not over-write existing file "'opath.3'"
  901. else
  902. cat << \SHAR_EOF > 'opath.3'
  903. .TH OPATH 3 "CONCURRENT"
  904. .SH NAME
  905. opath - Generate a UUCP route from an RFC822 address
  906. .br
  907. oupath - Generate a UUCP route from a (possibly disconnected) UUCP path
  908. .SH SYNOPSIS
  909. char *opath(s)
  910. .br
  911. char *s;
  912. .sp 1
  913. char *oupath(s)
  914. .br
  915. char *s;
  916. .SH DESCRIPTION
  917. These routines use the \fBpathalias\fR database to generate UUCP routing
  918. paths from your local site to specified remote sites on either the UUCP
  919. network or other connected networks.
  920. .PP
  921. \fBopath\fR takes one argument, an RFC822 address, as described in
  922. ADDRESS(1).  From this, it generates and returns a UUCP path to the site
  923. named in the argument.
  924. .PP
  925. \fBoupath\fR takes one argument, a UUCP path.  If the next site on this
  926. path is named \fIx\fR, \fBoupath\fR will prepend a path from your site to
  927. \fIx\fR, if \fIx\fR is nonadjacent to your site.  If \fIx\fR is a domain,
  928. i.e. contains a dot (.), \fBoupath\fR will generate a path to a gateway
  929. for this domain.  Note that \fBoupath\fR will \fInot\fR alter the argument
  930. path, other than to make the above transformations; it does not check whether
  931. sites in the argument are adjacent to one another, or whether they represent
  932. an optimal path; it is assumed that if the user has specified a path, then
  933. he wants to use that path.
  934. .PP
  935. The principal difference between \fBopath\fR and \fBoupath\fR is that the
  936. former gives precedence to ``@'', whereas the latter gives precedence
  937. to ``!''.  The former is intended to be invoked when receiving mail from
  938. a user interface or a non-UUCP source (if the subsequent transport mechanism
  939. is to be UUCP), whereas the latter is intended solely to be used by UUCP
  940. internal software, principally \fBrmail\fR, in routing mail through the
  941. UUCP network.
  942. .SH "FILES"
  943. \fI/usr/lib/uucp/palias\fR - The pathalias database.
  944. See PATHALIAS(1) for information; pathalias is a public-domain program
  945. distributed via the Usenet's net.sources facility.
  946. .br
  947. .sp 1
  948. \fI/usr/lib/uucp/domains\fR - The domain/gateway table.  Each line of this
  949. file consists of either a ``#'' followed by arbitrary comment text, or
  950. an entry of the form:
  951. .br
  952. .in 1i
  953. <domain>,<path>,<reserved>,<template>
  954. .br
  955. .in
  956. Where <domain> is the string (in capital letters) identifying a particular
  957. <path> is a string which may be included at an arbitrary point in the
  958. generated route, <reserved> is currently unused, and <template> is a string
  959. indicating the format of the generated route.
  960. .PP
  961. The <template> is a printf-style string; it is \fBnot\fR quoted, and
  962. begins at the character immediately following the comma which separates
  963. <template> from <reserved>.  The <template> may consist of arbitrary ASCII
  964. characters, which are copied unchanged into the generated route; or of
  965. a percent (%) sign followed by one of the following characters:
  966. .IP P
  967. The <path> string is inserted.  The <path> may consist either of a string
  968. which is inserted unchanged; or of the character ``>'' followed by the
  969. name of a UUCP site, in which case the entire <path> string is replaced
  970. with a string representing the path to the named site.  The last token on
  971. this string is the site named in the original <path> string, without a
  972. following ``!''.
  973. .IP U
  974. The user name from the original address is inserted.
  975. .IP N
  976. The site name from the original address, with the domain specifiers
  977. removed, is inserted.
  978. .IP D
  979. The site name from the original address, including the domain specifiers,
  980. is inserted.
  981. .IP R
  982. The UUCP path to the site named in the original address is looked up in
  983. the pathalias database and inserted.  Note that this path is looked up
  984. only when the %R is seen while scanning the <template>, so an error message
  985. for an invalid site name is generated if and only if it appears in an
  986. address with a domain which contains a %R in its template.
  987. .PP
  988. When making entries in the domain table, domain names which are a suffix of
  989. another domain name in the table should be ordered such that the longer
  990. string(s) appear first.  For example, .WA.UUCP should preceed .UUCP in
  991. the table.  A linear search is made of the table, and the first domain
  992. found in the table which is a suffix of the domain in the designated address
  993. is used as the domain in generating the routing.
  994. .PP
  995. Following are some example entries for the domain table.  Note that all
  996. domain names begin with a ``.''.
  997. .sp 1
  998. .nf
  999. .in 1i
  1000. # This is a comment
  1001. \&.HP.UUCP,,,%R!%U
  1002. \&.UUCP,,,%R!%U
  1003. \&.CSNET,>decwrl,,%P!%U%%%S@CSNET-RELAY.ARPA
  1004. \&.EDU,>ucbvax,,%P!%D
  1005. .in
  1006. .fi
  1007. .sp 1
  1008. .SH "SEE ALSO"
  1009. pathalias(1), address(1), rmail(1), uumail(8)
  1010. .SH "AUTHOR"
  1011. Eric Roskos, CONCURRENT COMPUTERS
  1012. .SH "NOTE"
  1013. The <reserved> field in the domain table currently has a function which
  1014. may be determined by examining the source code for opath.  However, this
  1015. function is a vestigal function provided for sites that used an earlier
  1016. version of opath; future opath versions will use this field for a different
  1017. purpose, and new users of opath therefore should \fBnot\fR use this field.
  1018. SHAR_EOF
  1019. if test 4889 -ne "`wc -c < 'opath.3'`"
  1020. then
  1021.     echo shar: error transmitting "'opath.3'" '(should have been 4889 characters)'
  1022. fi
  1023. fi
  1024. echo shar: extracting "'opath.c'" '(5753 characters)'
  1025. if test -f 'opath.c'
  1026. then
  1027.     echo shar: will not over-write existing file "'opath.c'"
  1028. else
  1029. cat << \SHAR_EOF > 'opath.c'
  1030. /*
  1031.  * opath.c - get an optimal uucp path from the path database, using an
  1032.  * RFC882-style address as input.  The '%' character is properly translated,
  1033.  * and gateway-substitution is done to get mail onto other networks.
  1034.  *
  1035.  *
  1036.  * Eric Roskos, Perkin-Elmer Corp. SDC
  1037.  * Version 3.2 created 85/09/12 15:21:51
  1038.  * $Log:    opath.c,v $
  1039.  * Revision 3.7  85/11/14  20:22:16  sob
  1040.  * Added #ifdef DEBUG to allow compiliation without DEBUG
  1041.  * 
  1042.  * Revision 3.6  85/11/08  03:05:22  sob
  1043.  * release version
  1044.  * 
  1045.  * Revision 3.5  85/10/09  03:20:07  sob
  1046.  * Added strindex call to make striping the printf stuff more pleasing.
  1047.  * 
  1048.  * Revision 3.4  85/09/30  02:49:12  sob
  1049.  * Updated to use getpath revised by Stan Barber
  1050.  * 
  1051.  * Revision 3.3  85/09/16  18:32:26  sob
  1052.  * This version will use the getpath subroutine used by uupath/uumail
  1053.  * and is not dependant on whether it is DBM or not.
  1054.  * Also uses the uuconf include file.
  1055.  * 
  1056.  * Revision 3.2  85/09/16  17:50:07  sob
  1057.  * Added to RCS
  1058.  * 
  1059.  */
  1060.  
  1061. static char *opathsccsid = "@(#)opath.c    3.2 (peora) 15:21:51 - 85/09/12";
  1062. static char opathrcsid[] = "$Header: opath.c,v 3.7 85/11/14 20:22:16 sob Exp $";
  1063. #ifdef OPATH
  1064. #include "uuconf.h"
  1065.  
  1066. /**
  1067.  ** User-configurable parameters
  1068.  **/
  1069.  
  1070. /**
  1071.  ** Global Variables
  1072.  **/
  1073.  
  1074. static char pval[150]; /* the path string is built here */
  1075.  
  1076. /*
  1077.  * the following are used to pass results by side-effect from the domain()
  1078.  * routine.
  1079.  */
  1080.  
  1081. static char prefix[80], suffix[80], fullsite[80];
  1082.  
  1083. /**
  1084.  ** Subroutines
  1085.  **/
  1086.  
  1087. /*
  1088.  * The Domain Table and its associated routines
  1089.  */
  1090.  
  1091. static struct domains
  1092. {
  1093.     char dom[50];
  1094.     char pre[50];
  1095.     char suf[50];
  1096.     char map[50];
  1097. } domtab[100];
  1098.  
  1099. /* Inline routine to copy a domain into the domain table */
  1100.  
  1101. #define DOMCPY(fld) { int i = 0; q=dp->fld; while (*p!=','&&*p!='\n'&&*p) \
  1102.             {*q++ = *p++; if (i++>=48) break;} \
  1103.             *q++ = '\0'; if (!*p) { \
  1104.             fprintf(stderr,"opath: fld(s) missing in %s at %s\n", \
  1105.             s, buf); \
  1106.             dp++; continue;} p++; }
  1107.  
  1108. /* Load the domain table from disk */
  1109.  
  1110. static int
  1111. loaddomtab(s)
  1112. char *s;
  1113. {
  1114. FILE *f;
  1115. char buf[100];
  1116. register char *p,*q;
  1117. struct domains *dp;
  1118.  
  1119.     f = fopen(s,"r");
  1120.     if (f==NULL)
  1121.     {
  1122.         fprintf(stderr,"opath: can't open domain file '%s'\n",s);
  1123.         exit(1);
  1124.     }
  1125.  
  1126.     dp = domtab;
  1127.  
  1128.     while (fgets(buf,100,f))
  1129.     {
  1130.         if (buf[0]=='#') continue; /* comments start with "#" */
  1131.         p = buf;
  1132.         DOMCPY(dom);
  1133.         DOMCPY(pre);
  1134.         DOMCPY(suf);
  1135.         DOMCPY(map);
  1136.         if (dp->map[0] == '\0')
  1137.         {
  1138.             fprintf(stderr,"opath: bad route template in %s\n",s);
  1139.             strcpy(dp->map,"Invalid");
  1140.         }
  1141.         dp++;
  1142.     }
  1143.  
  1144.     dp->map[0] = '\0';  /* mark end of table */
  1145.     fclose(f);
  1146.  
  1147.     return(0);
  1148. }
  1149.  
  1150. /* Get a UUCP path from the pathalias database 
  1151.  * and compensate for the format.
  1152.  * Typically the format is
  1153.  * site1!site2!site3!%s to be used in *printf statements.
  1154.  * We don't want the !%s, so we cut it off.
  1155.  * Pretty gross, but it works.
  1156.  */
  1157.  
  1158. static char *
  1159. gpath(s)
  1160. char *s;
  1161. {
  1162. static char path[100];
  1163. int getpath(),x;
  1164.     getpath(s,&path[0],paths);
  1165.         x=strindex(&path[0],"!%s");
  1166.     if (x >0) path[x] = '\0';
  1167. #ifdef DEBUG
  1168.     if (Debug>1)fprintf(stderr,"Getpath returns: %s\n",&path[0]);
  1169. #endif
  1170.     return(&path[0]);
  1171. }
  1172.  
  1173. /* returns location of tx in sx */
  1174. strindex(sx,tx)
  1175. char * sx, *tx;
  1176. {
  1177.     int i,n;
  1178.     n = strlen(tx);
  1179.     for (i=0;sx[i] != '\0'; i++)
  1180.         if (strncmp(sx+i,tx,n) ==0)
  1181.             return(i);
  1182.     return (-1);
  1183. }
  1184.  
  1185. /* String compare: entire first argument must match suffix of 2nd argument */
  1186.  
  1187. static int
  1188. domcmp(ss,tt)
  1189. char *ss, *tt;
  1190. {
  1191. char *s, *t;
  1192. int cmp;
  1193.  
  1194.     s = ss + strlen(ss) - 1;
  1195.     t = tt + strlen(tt) - 1;
  1196.  
  1197.     do
  1198.     {
  1199.         if (*s - *t) break;
  1200.         s--;
  1201.         t--;
  1202.     } while (s >= ss);
  1203.  
  1204.     if (++s == ss) return(0);
  1205.     else return(1);
  1206. }
  1207.  
  1208. /* Look up a domain, and by side effect set prefix and suffix appropriately */
  1209.  
  1210. char *domain(s)
  1211. char *s;
  1212. {
  1213. struct domains *d;
  1214. char *p;
  1215. static int loaded = 0;
  1216.  
  1217.     if (!loaded++) loaddomtab(ConfFile);
  1218.  
  1219.     if (*s!='.') /* default to UUCP domain */
  1220.     {
  1221.         prefix[0]=suffix[0]='\0';
  1222.         return("%R!%U");
  1223.     }
  1224.  
  1225.     for (p=s; *p; p++) if (*p>='a' && *p<='z') *p -= 'a'-'A';
  1226.  
  1227.     for (d = &domtab[0]; (int)d->map[0]; d++)
  1228.     {
  1229.         if (domcmp(d->dom,s)==0) break;
  1230.     }
  1231.  
  1232.     strcpy(prefix,(d->pre[0]=='>')? gpath(&d->pre[1]) : d->pre);
  1233.     strcpy(suffix,d->suf);
  1234.  
  1235.     return(d->map);
  1236. }
  1237.  
  1238. /* opath: generates a UUCP path from an RFC-822 address */
  1239.  
  1240. #define COPYON(s) {char *r; r=s; while (*r) *p++ = *r++; *p = '\0';}
  1241.  
  1242. char *
  1243. opath(s)
  1244. char *s;
  1245. {
  1246. char user[50],site[50];
  1247. static char cm[150];
  1248. FILE *f;
  1249. char *p, *q, *t;
  1250. char *d;
  1251. int i;
  1252. int found;
  1253. char *suf;
  1254.  
  1255.     for (p=user,q=s;(*p = *q)!='@'; p++,q++)
  1256.         if (*q=='\0') return(s);
  1257.     *p = '\0';
  1258.  
  1259.     strcpy(fullsite,++q);
  1260.  
  1261.     for (p=site;(*p = *q)!='.'; p++,q++)
  1262.         if (*q=='\0') break;
  1263.     *p = '\0';
  1264.  
  1265.     d = domain(q);
  1266.  
  1267.     if (d[0]=='\0') return(s); /* unknown domain - do nothing */
  1268.  
  1269.     for (p=pval, q=d; *q; q++)
  1270.     {
  1271.         if (*q=='%')
  1272.         {
  1273.             switch(*++q)
  1274.             {
  1275.             case 'P':
  1276.                 COPYON(prefix);
  1277.                 break;
  1278.  
  1279.             case 'S':
  1280.                 COPYON(suffix);
  1281.                 break;
  1282.  
  1283.             case 'U':
  1284.                 COPYON(user);
  1285.                 break;
  1286.  
  1287.             case 'N':
  1288.                 COPYON(site);
  1289.                 break;
  1290.  
  1291.             case 'D':
  1292.                 COPYON(fullsite);
  1293.                 break;
  1294.  
  1295.             case 'R':
  1296.                 COPYON(gpath(site));
  1297.                 break;
  1298.  
  1299.             case '%':
  1300.                 *p++ = '%';
  1301.                 break;
  1302.             }
  1303.         }
  1304.         else
  1305.             *p++ = *q;
  1306.     }
  1307.  
  1308.     return(pval);
  1309. }
  1310.  
  1311. /* oupath: generates a uucp path from a (possibly disconnected) uucp path */
  1312.  
  1313. char *oupath(s)
  1314. char *s;
  1315. {
  1316. char *p,*q;
  1317. static char adr[100];
  1318. char first[100];
  1319. int found;
  1320.  
  1321.     for (p=s,q=first,found=0; *p!='!' && *p!='\0'; p++)
  1322.     {
  1323.         if (*p=='.') found++;
  1324.         *q++ = *p;
  1325.     }
  1326.     if (*p=='\0') return (s);
  1327.  
  1328.     *q = '\0';
  1329.  
  1330.     if (found)
  1331.     {
  1332.         strcpy(adr,++p);
  1333.         strcat(adr,"@");
  1334.         strcat(adr,first);
  1335.         return(opath(adr));
  1336.     }
  1337.     else
  1338.     {
  1339.     int i;
  1340.         strcpy(adr,gpath(first));
  1341.         strcat(adr,/* ++ */p);
  1342.  
  1343.         return(adr);
  1344.     }
  1345. }
  1346.  
  1347.  
  1348. opathlog(fmt,a,b,c,d)
  1349. char *fmt;
  1350. int a,b,c,d;
  1351. {
  1352. FILE *f;
  1353.  
  1354.     f = fopen(logfile,"a");
  1355.     if (f==NULL) return;
  1356.  
  1357.     fprintf(f,fmt,a,b,c,d);
  1358.     fclose(f);
  1359. }
  1360. #endif
  1361. SHAR_EOF
  1362. if test 5753 -ne "`wc -c < 'opath.c'`"
  1363. then
  1364.     echo shar: error transmitting "'opath.c'" '(should have been 5753 characters)'
  1365. fi
  1366. fi
  1367. echo shar: extracting "'rmail.c'" '(2622 characters)'
  1368. if test -f 'rmail.c'
  1369. then
  1370.     echo shar: will not over-write existing file "'rmail.c'"
  1371. else
  1372. cat << \SHAR_EOF > 'rmail.c'
  1373. #ifndef lint
  1374. static char rcsid[]="$Header: rmail.c,v 1.3 85/11/08 03:05:31 sob RELEASE $";
  1375.  
  1376. #endif
  1377.  
  1378. /*
  1379. **  RMAIL -- UUCP mail server.
  1380. **
  1381. **    This program reads the >From ... remote from ... lines that
  1382. **    UUCP is so fond of and turns them into something reasonable.
  1383. **    It calls uumail giving it a -f option built from these
  1384. **    lines.
  1385. */
  1386.  
  1387. #define _DEFINE
  1388.  
  1389. #include "uuconf.h"
  1390. extern FILE *popen();
  1391. extern char *index();
  1392. extern char *rindex();
  1393.  
  1394. # define MAILER    "/usr/lib/uucp/uumail"
  1395.  
  1396. main(argc, argv)
  1397.     char **argv;
  1398. {
  1399.     FILE *out;    /* output to mail handler */
  1400.     char lbuf[512];    /* one line of the message */
  1401.     char from[512];    /* accumulated path of sender */
  1402.     char ufrom[64];    /* user on remote system */
  1403.     char sys[64];    /* a system in path */
  1404.     char junk[512];    /* scratchpad */
  1405.     char cmd[2000];
  1406.     register char *cp;
  1407.     register char *uf;    /* ptr into ufrom */
  1408.     int i;
  1409.  
  1410. # ifdef DEBUG
  1411.     if (argc > 1 && strcmp(argv[1], "-T") == 0)
  1412.     {
  1413.         Debug = TRUE;
  1414.         argc--;
  1415.         argv++;
  1416.     }
  1417. # endif DEBUG
  1418.  
  1419.     if (argc < 2)
  1420.     {
  1421.         fprintf(stderr, "Usage: rmail user ...\n");
  1422.         exit(EX_USAGE);
  1423.     }
  1424.  
  1425.     (void) strcpy(from, "");
  1426.     (void) strcpy(ufrom, "/dev/null");
  1427.  
  1428.     for (;;)
  1429.     {
  1430.         (void) fgets(lbuf, sizeof lbuf, stdin);
  1431.         if (strncmp(lbuf, "From ", 5) != 0 && strncmp(lbuf, ">From ", 6) != 0)
  1432.             break;
  1433.         (void) sscanf(lbuf, "%s %s", junk, ufrom);
  1434.         cp = lbuf;
  1435.         uf = ufrom;
  1436.         for (;;)
  1437.         {
  1438.             cp = index(cp+1, 'r');
  1439.             if (cp == NULL)
  1440.             {
  1441.                 register char *p = rindex(uf, '!');
  1442.  
  1443.                 if (p != NULL)
  1444.                 {
  1445.                     *p = '\0';
  1446.                     if (uf != NULL) 
  1447.                         (void) strcpy(sys, uf);
  1448.                     else
  1449.                         gethostname(sys,32);
  1450.                     uf = p + 1;
  1451.                     break;
  1452.                 }
  1453.                 cp = "remote from somewhere";
  1454.             }
  1455. #ifdef DEBUG
  1456.             if (Debug)
  1457.                 printf("cp='%s'\n", cp);
  1458. #endif
  1459.             if (strncmp(cp, "remote from ", 12)==0)
  1460.                 break;
  1461.         }
  1462.         if (cp != NULL)
  1463.             (void) sscanf(cp, "remote from %s", sys);
  1464.         (void) strcat(from, sys);
  1465.         (void) strcat(from, "!");
  1466. #ifdef DEBUG
  1467.         if (Debug)
  1468.             printf("ufrom='%s', sys='%s', from now '%s'\n", uf, sys, from);
  1469. #endif
  1470.     }
  1471.     (void) strcat(from, uf);
  1472.  
  1473. /*    (void) sprintf(cmd, "exec %s -em -f%s", MAILER, from);*/
  1474.     (void) sprintf(cmd, "exec %s -f%s", MAILER,from);
  1475.     while (*++argv != NULL)
  1476.     {
  1477.         (void) strcat(cmd, " '");
  1478.         if (**argv == '(')
  1479.             (void) strncat(cmd, *argv + 1, strlen(*argv) - 2);
  1480.         else
  1481.             (void) strcat(cmd, *argv);
  1482.         (void) strcat(cmd, "'");
  1483.     }
  1484. #ifdef DEBUG
  1485.     if (Debug)
  1486.         printf("cmd='%s'\n", cmd);
  1487. #endif
  1488.     out = popen(cmd, "w");
  1489.     fputs(lbuf, out);
  1490.     while (fgets(lbuf, sizeof lbuf, stdin))
  1491.         fputs(lbuf, out);
  1492.     i = pclose(out);
  1493.     if ((i & 0377) != 0)
  1494.     {
  1495.         fprintf(stderr, "pclose: status 0%o\n", i);
  1496.         exit(EX_OSERR);
  1497.     }
  1498.  
  1499.     exit((i >> 8) & 0377);
  1500. }
  1501. SHAR_EOF
  1502. if test 2622 -ne "`wc -c < 'rmail.c'`"
  1503. then
  1504.     echo shar: error transmitting "'rmail.c'" '(should have been 2622 characters)'
  1505. fi
  1506. fi
  1507. echo shar: extracting "'uuconf.h'" '(3241 characters)'
  1508. if test -f 'uuconf.h'
  1509. then
  1510.     echo shar: will not over-write existing file "'uuconf.h'"
  1511. else
  1512. cat << \SHAR_EOF > 'uuconf.h'
  1513. /* $Header: uuconf.h,v 1.5 85/12/10 20:42:30 sob Exp $
  1514.  * Configuration for uumail and uupath utilities
  1515.  * Please see the header for makefile for changes you may
  1516.  * need to make there.
  1517.  * $Log:    uuconf.h,v $
  1518.  * Revision 1.5  85/12/10  20:42:30  sob
  1519.  * Added defines for new parts of getpath, SENTINAL and TIMEOUT
  1520.  * 
  1521.  * Revision 1.4  85/10/02  02:16:21  sob
  1522.  * Added LOCALMAIL definition
  1523.  * 
  1524.  * Revision 1.3  85/09/30  02:50:51  sob
  1525.  * Added pwd.h to list of include files
  1526.  * 
  1527.  * Revision 1.2  85/07/11  19:29:34  sob
  1528.  * *** empty log message ***
  1529.  * 
  1530.  * Revision 1.1  85/07/11  19:22:20  sob
  1531.  * Initial revision
  1532.  * 
  1533.  */
  1534. #include <stdio.h>
  1535. #include <ctype.h>
  1536. #include <pwd.h>
  1537. #include <signal.h>
  1538. #include <setjmp.h>
  1539.  
  1540. /*
  1541.  * sysexits is a file of exit codes that are used in sendmail
  1542.  * and other programs ...
  1543.  */
  1544. #include <sysexits.h>
  1545. /* if you don't have sysexits.h here are the useful parts */
  1546. #ifndef EX_OK
  1547.  
  1548. # define EX_OK        0    /* successful termination */
  1549.  
  1550.  
  1551. # define EX_USAGE    64    /* command line usage error */
  1552. # define EX_DATAERR    65    /* data format error */
  1553. # define EX_NOINPUT    66    /* cannot open input */
  1554. # define EX_NOHOST    68    /* host name unknown */
  1555. # define EX_UNAVAILABLE    69    /* service unavailable */
  1556. # define EX_SOFTWARE    70    /* internal software error */
  1557. # define EX_OSERR    71    /* system error (e.g., can't fork) */
  1558. # define EX_OSFILE    72    /* critical OS file missing */
  1559. # define EX_CANTCREAT    73    /* can't create (user) output file */
  1560. # define EX_IOERR    74    /* input/output error */
  1561. # define EX_TEMPFAIL    75      /* temp failure; user should retry */
  1562. #endif
  1563.  
  1564. typedef char bool;
  1565.  
  1566. #ifdef DBM
  1567. #include <dbm.h>
  1568. #endif
  1569.  
  1570. #ifdef SYSIII
  1571. #define index strchr
  1572. #define rindex strrchr
  1573. #include <sys/utsname.h>
  1574. #endif
  1575.  
  1576. #define NAMESIZ 32 /* system name size */
  1577. #define PATHSIZ 16*NAMESIZ /* path length */
  1578.  
  1579. #define TRUE    1
  1580. #define FALSE    0
  1581.  
  1582. #ifndef TIMEOUT
  1583. #define TIMEOUT ((unsigned) 180)
  1584. #endif TIMEOUT
  1585.  
  1586. #ifndef SENTINEL
  1587. #define SENTINEL "@@@"
  1588. #endif SENTINEL
  1589.  
  1590. /* Here's where you should put in the the name of the file
  1591.  * in which the uucpmap data is kept.
  1592.  * For those using DBM, this will be the root filename for the database
  1593.  * (eg... file.pag and file.dir with root name file)
  1594.  */
  1595.  
  1596. #define DATABASE "/usr/lib/uucp/palias"
  1597. #define CONFIGFILE "/usr/lib/uucp/domains"
  1598. #define LOGFILE "/usr/adm/uumail.log"
  1599. /* this needs to be a printf-like string to deliver LOCAL mail */
  1600. /* usually this is either /bin/mail or /bin/binmail */
  1601.  
  1602. #define LOCALMAIL "/bin/bellmail %s"
  1603.  
  1604. #ifdef _DEFINE
  1605. #define EXTERN 
  1606. #else
  1607. #define EXTERN extern
  1608. #endif
  1609.  
  1610. EXTERN int Debug;
  1611. EXTERN char *paths;
  1612. EXTERN char *ConfFile;
  1613. EXTERN char Myname[NAMESIZ];
  1614. EXTERN char *logfile;
  1615. EXTERN char    OpMode;        /* operation mode, see below */
  1616. /* These don't do anything yet.... next time they will do something */
  1617. #define MD_DELIVER    'm'        /* be a mail sender */
  1618. #define MD_ARPAFTP    'a'        /* old-style arpanet protocols */
  1619. #define MD_SMTP        's'        /* run SMTP on standard input */
  1620. #define MD_DAEMON    'd'        /* run as a daemon */
  1621. #define MD_VERIFY    'v'        /* verify: don't collect or deliver */
  1622. #define MD_TEST        't'        /* test mode: resolve addrs only */
  1623. #define MD_INITALIAS    'i'        /* initialize alias database */
  1624. #define MD_PRINT    'p'        /* print the queue */
  1625. #define MD_FREEZE    'z'        /* freeze the configuration file */
  1626. SHAR_EOF
  1627. if test 3241 -ne "`wc -c < 'uuconf.h'`"
  1628. then
  1629.     echo shar: error transmitting "'uuconf.h'" '(should have been 3241 characters)'
  1630. fi
  1631. fi
  1632. echo shar: extracting "'uumail.1'" '(2280 characters)'
  1633. if test -f 'uumail.1'
  1634. then
  1635.     echo shar: will not over-write existing file "'uumail.1'"
  1636. else
  1637. cat << \SHAR_EOF > 'uumail.1'
  1638. .TH "UUMAIL" "8" "Baylor College of Medicine"
  1639. .fi
  1640. .ad b
  1641. .SH NAME
  1642. uumail \- rewrite address & route mail using uucpmap database 
  1643. .br
  1644. uupath \- print the uucp path to a host
  1645. .SH SYNOPSIS
  1646. .B uumail [ \fIoptions\fR ] \fIaddress\fR
  1647. .br
  1648. .B uupath \fIhostname\fR
  1649. .SH DESCRIPTION
  1650. .B Uumail
  1651. is designed to be used as a mail delivery program to correctly
  1652. route mail over uucp connections.
  1653. .SS Standard Options
  1654. .IP "-f\fIaddress\fR" 16
  1655. The -f option sets the address of the sender of the mail. If this flag 
  1656. is not used, the sender will be established by usings environmental variables
  1657. (like 
  1658. .B LOGNAME
  1659. and
  1660. .B USER
  1661. ) or using getlogin(3).
  1662. .IP "-m" 16
  1663. The -m option causes the mail to also be sent to the sender of the message.
  1664. .IP "-c" 16
  1665. The -c option causes
  1666. .B uucico 
  1667. to be started immediately after queuing the mail.
  1668. The default just queues the mail.
  1669. .IP "-h" 16
  1670. The -h option causes no From_ line to be added to the beginning of file.
  1671. This is useful when uumail is being used as a mailer for sendmail(8).
  1672. .SS Compile-time Configurable Options
  1673. .IP "-d[1-6]" 16
  1674. The -d option turns on the limited debugging facility built into the
  1675. mailer.  In debug mode, the mailer does not actually mail anything, but
  1676. tells you what it would do if it did do it. The level of debugging can
  1677. be set by following the 
  1678. .I -d
  1679. flag with a number between 1 and 6.
  1680. .IP "-g[A-Z]" 16
  1681. If your 
  1682. .B uux(1)
  1683. supports grading of transactions, the -g option can be used to set the
  1684. grade of this mail. A grade of \fIC\fR is used by default.
  1685.  
  1686. .SS Arguments
  1687. .IP \fIhost!user\fR 16
  1688. where host is a system node name on the network and user is the login
  1689. name of the addressee.
  1690. .IP \fIuser@host.domain\fR
  1691. same as above with the addition of a domain specifier like
  1692. .B .ARPA, .GOV, .COM, .EDU
  1693. etc.
  1694. .SH FILES
  1695. .IP "/usr/lib/uucp/palias" 20
  1696. Path file produced by pathalias.
  1697. .IP "/usr/lib/uucp/uucp/domains" 20
  1698. Domain rewriting rules for opath(3).
  1699. .IP "/usr/adm/uumail.log" 20
  1700. Log of uumail activity.
  1701. .SH "SEE ALSO"
  1702. pathalias(1), Pnews(1), Rnmail(1), rn(1), postnews(1), readnews(1),
  1703. opath(3), sendmail(8)
  1704.  
  1705. .SH AUTHORS
  1706. .br
  1707. Stan Barber, Baylor College of Medicine
  1708. .br
  1709. Getpath routine by John Donnelly, University of Illinois
  1710. .br
  1711. Gethostname routine by Peter Honeyman, Princeton
  1712. .br
  1713. Opath routine by Eric Roskos, CONCURRENT Computers
  1714.  
  1715. SHAR_EOF
  1716. if test 2280 -ne "`wc -c < 'uumail.1'`"
  1717. then
  1718.     echo shar: error transmitting "'uumail.1'" '(should have been 2280 characters)'
  1719. fi
  1720. fi
  1721. echo shar: extracting "'uumail.c'" '(12804 characters)'
  1722. if test -f 'uumail.c'
  1723. then
  1724.     echo shar: will not over-write existing file "'uumail.c'"
  1725. else
  1726. cat << \SHAR_EOF > 'uumail.c'
  1727. /*
  1728.  *  U U M A I L
  1729.  *  This program when invoked in the form:
  1730.  *  uumail host!user will consult the local usemap for
  1731.  *  the proper routing.
  1732.  * 
  1733.  *  If it finds it, it will invoke the proper uux call
  1734.  *  to send the mail.
  1735.  *  Otherwise it aborts with an error 68 (host unknown)
  1736.  * $Log:    uumail.c,v $
  1737.  * Revision 2.9  85/12/10  20:36:01  sob
  1738.  * Added new return flag from getpath EX_TEMPFAIL to signal that the
  1739.  * path database is currently being updated.
  1740.  * 
  1741.  * Revision 2.8  85/12/02  16:51:39  sob
  1742.  * Added a fix to cope with percents in addresses returned by opath.
  1743.  * Thank to steve@umd-cs.UUCP for the bug report.
  1744.  * 
  1745.  * Revision 2.7  85/11/18  12:36:48  sob
  1746.  * Added the -h option to cause uumail NOT to add a From_ line.
  1747.  * 
  1748.  * Revision 2.6  85/11/14  20:20:06  sob
  1749.  * Added #ifdef DEBUG to allow compiliation with out DEBUG installed
  1750.  * 
  1751.  * Revision 2.5  85/11/14  20:14:11  sob
  1752.  * Another little buggie in the log format...sheesh.
  1753.  * 
  1754.  * Revision 2.4  85/11/13  15:53:18  sob
  1755.  * Reformated the log file a little bit.
  1756.  * 
  1757.  * Revision 2.3  85/11/08  03:03:51  sob
  1758.  * This is the release version.
  1759.  * 
  1760.  * 
  1761.  * Revision 2.2  85/09/30  02:51:18  sob
  1762.  * This version uses opath when defined during compile time.
  1763.  * With a bit of cleaning up, this is a release version.
  1764.  * 
  1765.  * Revision 2.1  85/09/30  02:46:06  sob
  1766.  * *** empty log message ***
  1767.  * 
  1768.  * Revision 2.0  85/09/09  18:22:56  UUCP
  1769.  * *** empty log message ***
  1770.  * 
  1771.  * Revision 2.0  85/09/09  18:22:56  UUCP
  1772.  * Added flags to conform with sendmail. Also updated the flags it could send
  1773.  * to uux to conform with 4.3 uux command.
  1774.  * Will add name resolution and header checking.
  1775.  * Also will allow multiple addresses per line.
  1776.  * 
  1777.  * Revision 1.7  85/08/03  00:49:14  UUCP
  1778.  * Cleaned up with lint.
  1779.  * Stan Barber
  1780.  * 
  1781.  * Revision 1.6  85/07/11  19:30:00  sob
  1782.  * changed PATHSIZE to PATHSIZ to conform with uupath
  1783.  * 
  1784.  * Revision 1.5  85/07/11  18:08:13  sob
  1785.  * This one works both as uumail and uupath!
  1786.  * Stan
  1787.  * 
  1788.  * Revision 1.4  85/07/10  18:35:05  sob
  1789.  * moved DBM to getpath
  1790.  * Stan Barber
  1791.  * 
  1792.  * Revision 1.3  85/07/09  01:28:14  sob
  1793.  * First attempt to integrate uupath
  1794.  * Not successful. Changed PATHALIAS define
  1795.  * to DBM... will ultimately alter getpath as well
  1796.  * added gethostname call to fill in for local host.
  1797.  * 
  1798.  * Revision 1.2  85/07/08  05:29:16  sob
  1799.  * This one works with pathalias database...
  1800.  * need to modify to substitue for uupath.
  1801.  * Stan
  1802.  * 
  1803.  * Revision 1.1  85/07/08  03:11:10  sob
  1804.  * Initial revision
  1805.  * 
  1806.  */
  1807. #define _DEFINE
  1808.  
  1809. #include "uuconf.h"
  1810.  
  1811.  
  1812. EXTERN bool uupath;
  1813. extern int      errno;
  1814. extern struct passwd *getpwuid();
  1815. extern FILE    *popen();
  1816. extern char     *ctime();
  1817. extern char    *getlogin();
  1818. extern char    *index();
  1819. extern char    *rindex();
  1820. extern char    *malloc();
  1821. extern char     *getenv();
  1822. EXTERN char    progname[12];
  1823. EXTERN char  *paths;
  1824. int local;
  1825. char templet[64];
  1826. char * from;
  1827.  
  1828.  
  1829. static char Version[] ="$Header: uumail.c,v 2.9 85/12/10 20:36:01 sob Exp $";
  1830.  
  1831. main(argc, argv)
  1832.     char **argv;
  1833. {
  1834.     FILE *out, *tmpf;    /* output to uux, temp file */
  1835.     char lbuf[512]; /* for pipe to uux */
  1836.     char sender[512];    /* accumulated path of sender */
  1837.     char sys[64];    /* a system in path */
  1838.     char cmd[2000];
  1839.     char **av;
  1840.     int i,
  1841.             error = 0,
  1842.             bangcnt, hopcount = 30,
  1843.         metoo=0, noheader = 0,
  1844.         startuux ;
  1845.         
  1846.     char    c,
  1847.             grade = 'C',
  1848.        name[20],             /* The system name (if any) */
  1849.        *fname,
  1850.        *path,            /* uupath to the system */
  1851.            *sysname,            /* points to the system name */
  1852.            *p, *q, *r,            /* tmp pointer to argv's */
  1853.        *rsys,
  1854.        *FullName;
  1855.        bool GrabTo,safecf,NoAlias;
  1856.        extern intsig();
  1857.  
  1858.     if (signal(SIGINT, SIG_IGN) != SIG_IGN)
  1859.         (void) signal(SIGINT, intsig);
  1860.     if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
  1861.         (void) signal(SIGHUP, intsig);
  1862.     (void) signal(SIGTERM, intsig);
  1863.     (void) signal(SIGPIPE, SIG_IGN);
  1864.  
  1865.  
  1866.     for (i = 3; i < 20; i++)
  1867.         (void) close(i);
  1868.     errno = 0;
  1869.     gethostname(Myname,32);
  1870.     paths=DATABASE;
  1871.     logfile=LOGFILE;
  1872.     argv[argc] = NULL;
  1873.     av = argv;
  1874.     p = rindex(*av, '/');
  1875.     if (p++ == NULL)
  1876.         p = *av;
  1877.     strcpy(progname ,p);
  1878.     if(strcmp(p,"uupath") == 0)
  1879.         uupath = TRUE;
  1880.     while ((p = *++av) != NULL && p[0] == '-')
  1881.     {
  1882.         switch (p[1])
  1883.         {
  1884.  
  1885.           case 'C':    /* select configuration file */
  1886.             ConfFile = &p[2];
  1887.             safecf = FALSE;
  1888.  
  1889.             break;
  1890.  
  1891.           case 'g':   /* set grade */
  1892.             grade = p[2];
  1893.             break;
  1894.     
  1895. # ifdef DEBUG
  1896.           case 'd':    /* debug */
  1897.             Debug= atoi(&p[2]);
  1898.             if (Debug == 0) Debug = 1;
  1899.             setbuf(stdout, (char *) NULL);
  1900.             printf("Version %s\n", Version);
  1901.             break;
  1902. # endif DEBUG
  1903.  
  1904.           case 'f':    /* from address */
  1905.           case 'r':    /* obsolete -f flag */
  1906.             p += 2;
  1907.             if (*p == '\0' && ((p = *++av) == NULL || *p == '-'))
  1908.             {
  1909.                 p = *++av;
  1910.                 if (p == NULL || *p == '-')
  1911.                 {
  1912.                     syserr("No \"from\" person");
  1913.                     av--;
  1914.                     break;
  1915.                 }
  1916.             }
  1917.             if (from != NULL)
  1918.             {
  1919.                 syserr("More than one \"from\" person");
  1920.                 break;
  1921.             }
  1922.             from = p;
  1923.             break;
  1924.  
  1925.           case 'w':    /* just print the path */
  1926.             uupath = TRUE;
  1927.             break;
  1928.           case 'm':    /* send to me too */
  1929.             metoo = TRUE;
  1930.             break;
  1931.           case 'c':    /* connect to non-local mailers */
  1932.             startuux= TRUE;
  1933.             break;
  1934.           case 'h':    /* don't add a From line */
  1935.             noheader = TRUE;
  1936.             break;
  1937.             }
  1938.     
  1939.         }
  1940.  
  1941.     if(*av==NULL && GrabTo!= TRUE)
  1942.     {
  1943.         fprintf(stderr,"Usage: %s [flags] address\n",progname);
  1944.         exit(EX_USAGE);
  1945.     }
  1946.  
  1947.     if (ConfFile == NULL) ConfFile = CONFIGFILE;
  1948.  
  1949.     if(from==NULL || strlen(from) == 0){
  1950.         if (((from = getenv("LOGNAME")) == NULL) || (strlen(from) == 0))
  1951.             from = getenv("USER");
  1952.         if ((from == NULL) || (strlen(from) == 0))
  1953.             from = getlogin();
  1954.         if ((from == NULL) || (strlen(from) == 0))
  1955.             from = getpwuid(geteuid())->pw_name;
  1956.     }
  1957.  
  1958. if (!uupath)
  1959. {    
  1960. #ifdef DEBUG
  1961.     if (Debug) printf("Mail from %s\n",from);
  1962. #endif
  1963.     /*
  1964.      * Make temporary file for letter
  1965.      * (I wish ACCESS(2) would take care of this better !!)
  1966.      */
  1967.     if ((p=getenv("HOME"))== NULL)
  1968.         p="/tmp";
  1969.     sprintf(&templet[0],"%s/.uumXXXXXX",p);
  1970.     mktemp(templet);
  1971.     unlink(templet);
  1972.     if ((i=open(templet,2)) < 0)
  1973.         {
  1974.             p="/tmp";
  1975.     
  1976.             sprintf(&templet[0],"%s/.uumXXXXXX",p);
  1977.             mktemp(templet);
  1978.             unlink(templet);
  1979.         }
  1980.     else
  1981.         {
  1982.             close(i);
  1983.             unlink(templet);
  1984.         }
  1985. #ifdef DEBUG
  1986.     if (Debug>2) printf("Temp file is %s\n",templet);
  1987. #endif
  1988.     if((tmpf = fopen(templet, "w")) == NULL){
  1989.         fprintf(stderr, "%s : can't open %s for writing\n", progname,templet);
  1990.         fclose(stdin);
  1991.         exit(EX_CANTCREAT);
  1992.  
  1993.         }
  1994.     while(fgets(lbuf,sizeof lbuf,stdin))
  1995.         fputs(lbuf,tmpf);
  1996.     fclose(tmpf);
  1997.     fclose(stdin);
  1998. /* file now saved */
  1999.     if((tmpf = fopen(templet, "r")) == NULL){
  2000.         fprintf(stderr, "%s : can't open %s for reading\n", progname,templet);
  2001.         exit(EX_OSERR);
  2002.     }
  2003.     
  2004. }    
  2005.     (void) strcpy(sender, "");
  2006.  
  2007.     path = malloc(PATHSIZ);
  2008.  
  2009.     av--;
  2010.  
  2011.     if(metoo)
  2012.     {
  2013.     *av = from;
  2014.     av --;
  2015.     }
  2016.     
  2017.     while (av++ != NULL && *av != NULL)
  2018.     {
  2019.     local = bangcnt = 0;
  2020.     
  2021.     
  2022.     q = p = *av;
  2023.     
  2024.     sysname = &name[0];
  2025.  
  2026.     
  2027.     if (uupath) 
  2028.  
  2029.     {
  2030.     (void) strcpy(sysname ,p);
  2031. #ifdef OPATH
  2032.     if ((error = getpath (&name[0], path,paths)) != EX_OK)
  2033.         {
  2034.         if (error == EX_NOHOST) fprintf (stderr, "System %s not found in network map\n", &name[0]);
  2035.         if (error == EX_NOINPUT) fprintf(stderr,"Database %s could not be opened\n",paths);
  2036.         if (error == EX_TEMPFAIL) fprintf(stderr,"Database %s is being updated\nTry again later.\n",paths);
  2037.         exit(EX_NOHOST);
  2038.         }
  2039.     }
  2040.     else 
  2041.     if (index(p,'@') == NULL) strcpy(path,oupath(p)); 
  2042.         else strcpy(path,opath(p));
  2043.  
  2044. /* fix string to allow % to be untranslated by printf and 
  2045.  * friends 
  2046.  */
  2047.    if ((r=index(path,'%')) != NULL)
  2048.     {
  2049.         char t[PATHSIZ];
  2050.         strncpy(t,path,(r-path));
  2051.         strcat(t,"%");
  2052.         strcat(t,r);
  2053.         path = &t[0];
  2054. #ifdef DEBUG
  2055.     if (Debug>3)
  2056.         fprintf(stderr,"In percent fix, %s\n",t);
  2057. #endif
  2058.     }
  2059.  
  2060.  
  2061.  
  2062.  
  2063. #ifdef DEBUG
  2064.     if (Debug >1) fprintf(stderr,"Opath returns %s\n",path);
  2065. #endif
  2066.  
  2067.     if (path[0] == '!')  /* no match in pathalias database */
  2068.     {
  2069.         deadletter(tmpf,local);
  2070.         unlink(templet);
  2071.         exit(EX_NOHOST);
  2072.     }
  2073.    
  2074.    if (strcmp(path,p) == 0)
  2075.     {
  2076.     strcpy(path,Myname);
  2077.     local = 1;
  2078.     }
  2079.  
  2080. #else
  2081.     }
  2082.     else
  2083. {
  2084.     do                        /* count bangs */
  2085.         {
  2086.             while (((c = *p++) != '!') && (c != '\0'));
  2087.                 if (c == '!') bangcnt++;
  2088.         }
  2089.     while (c != '\0' && bangcnt == 1);
  2090.         ;
  2091.     if (bangcnt >= 1)                /* expand path */
  2092.         {
  2093.             while ((*sysname++ = *q++) != '!');
  2094.                 *--sysname = '\0';
  2095.  
  2096.             }
  2097.     /* insert code here to look at uucp neighbors & local host */
  2098.     if (bangcnt == 0) {
  2099.             strcpy(sysname,Myname);
  2100.             local = 1;
  2101.             }
  2102.     }
  2103. #ifdef DEBUG
  2104.     if (Debug>1) printf("sysname = %s\n",&name[0]);
  2105. #endif
  2106.     
  2107.     if (!local && (error = getpath (&name[0], path,paths)) != EX_OK)
  2108.         {
  2109.         if (error == EX_NOHOST) fprintf (stderr, "System %s not found in network map\n", &name[0]);
  2110.         if (error == EX_NOINPUT) fprintf(stderr,"Database %s could not be opened\n",paths);
  2111.         if (error == EX_TEMPFAIL) fprintf(stderr,"Database %s is being updated\nTry again later.\n",paths);
  2112.         exit(EX_NOHOST);
  2113.         }
  2114.  
  2115.        if (local) path = sysname;
  2116. #endif
  2117.  
  2118.  
  2119. #ifdef DEBUG
  2120.        if(Debug>1) printf("Path = %s\n",path);
  2121. #endif
  2122.  
  2123.     p = q;                    /* save name */
  2124.     for (i = 0; i < 1 && *p != '\0'; p++)
  2125.         if (*p == '/')
  2126.         i++;
  2127.     fname = &sender[0];
  2128.  
  2129.         if (uupath)
  2130.         sprintf(fname,path,"username");
  2131.     else
  2132.         sprintf(fname,path,q);
  2133.  
  2134.     p = &sender[0];
  2135.     rsys = &sys[0];
  2136.  
  2137.     if (!local)
  2138.         {
  2139.         while((*rsys++ = *p++) != '!');
  2140.         *--rsys = '\0';
  2141.         }
  2142.         else
  2143. /* local host, remove @ sign */
  2144.         {
  2145.         strcpy(rsys,*av);
  2146.         q=rsys;
  2147.         if (index(rsys,'@') != 0)
  2148.             { 
  2149.                 while (*q++ !='@');
  2150.                 *--q='\0';
  2151.             }
  2152.         /* assume that if it has a bang in it uux
  2153.             will either reject it or know what to do with it */
  2154.         /* this is a little gross */
  2155.         if ((q = index(rsys,'!')) != 0)
  2156.             {
  2157.             local=0;
  2158.             strcpy(&sys[0],rsys);
  2159.             sys[q-rsys]='\0';
  2160.             p=q+1;
  2161.             }
  2162.     }
  2163.         
  2164.     if ((!local && *fname =='\0') || (local && &sys[0]=='\0')) {
  2165.         fprintf(stdout, "null name\n");
  2166.         exit(EX_DATAERR);
  2167.     }
  2168. #ifdef DEBUG
  2169.     if (Debug>3)
  2170.         printf("p = %s sys = %s fname = %s\n",p, &sys[0],fname);
  2171. #endif
  2172.  
  2173.     if (uupath)
  2174.         {
  2175.         printf ("Path to %s:  %s\n", *av, fname);
  2176.         continue;
  2177.         }
  2178.     else
  2179.     {
  2180.         if (local)
  2181.             sprintf(cmd, LOCALMAIL, &sys[0]);
  2182.         else {
  2183.             strcpy(cmd,"uux - ");
  2184.         if (!startuux)
  2185.             strcat(cmd,"-r");
  2186. #ifndef NORETURN
  2187.         if (from)
  2188.             {
  2189.             strcat(cmd," -a");
  2190.             strcat(cmd,from);
  2191.             }
  2192. #endif
  2193. #ifndef NOGRADE
  2194.         if (grade)
  2195.             {
  2196.             char work[10];
  2197.             sprintf(work," -g%c",grade);
  2198.             strcat(cmd,work);
  2199.             }
  2200. #endif        
  2201.         if (index(p, '!'))
  2202.             {
  2203.                 char work[100];
  2204.                 sprintf(work, " %s!rmail \\(%s\\)",  &sys[0], p);
  2205.                 strcat(cmd,work);
  2206.             }
  2207.         else
  2208.             {
  2209.                 char work[100];
  2210.                 sprintf(work, " %s!rmail %s", &sys[0], p);
  2211.                 strcat(cmd,work);
  2212.             }
  2213.         }
  2214. #ifdef DEBUG
  2215.     if (Debug) fprintf(stderr,"Command is %s\n",cmd);
  2216. #endif
  2217.         rewind(tmpf);
  2218. #ifdef DEBUG
  2219.         if (Debug)
  2220.             out = fopen("UUMAIL.TEST","w");
  2221.         else
  2222. #endif
  2223.             out = popen(cmd, "w");
  2224. /*        fputs(lbuf, out); */
  2225.         if (!noheader) Putfrom(tmpf,out);
  2226.         while (fgets(lbuf, sizeof lbuf, tmpf))
  2227.             fputs(lbuf, out);
  2228.  
  2229. /* may not be needed */
  2230.         if (local)
  2231.             fprintf(out,"\n.\n");
  2232.  
  2233. #ifdef DEBUG
  2234.         if (Debug)
  2235.             i = fclose(out);
  2236.         else
  2237. #endif
  2238.             i = pclose(out);
  2239.         if ((i & 0377) != 0)
  2240.             {
  2241.                 fprintf(stderr, "pclose: status 0%o\n", i);
  2242.                 deadletter(tmpf,local);
  2243. #ifdef DEBUG
  2244.                 if (Debug <3) unlink(templet);
  2245. #endif
  2246.                 exit(EX_OSERR);
  2247.             }
  2248. #ifdef LOG
  2249.         maillog(cmd);
  2250. #endif
  2251.        }
  2252.     }
  2253. #ifdef DEBUG
  2254.     if (Debug <3) unlink(templet);
  2255. #endif
  2256. exit(EX_OK);
  2257. }
  2258.  
  2259. /* print an error message on stderr */
  2260.  
  2261. syserr(string)
  2262. char * string;
  2263. {
  2264.     fprintf(stderr,"%s\n",string);
  2265. }
  2266.  
  2267. /* make a unix type From line and send it out the stream */
  2268.  
  2269. Putfrom(into,outto)
  2270. FILE *into, *outto;
  2271. {
  2272.     char    *asctime();
  2273.     struct    tm *bp, *localtime();
  2274.     char    *tp, *zp;
  2275.     int    n,fromflag=0;
  2276.     char buf[128];
  2277.     long iop;
  2278.  
  2279.     /*
  2280.      * Format time
  2281.      */
  2282.     time(&iop);
  2283.     bp = localtime(&iop);
  2284.     tp = asctime(bp);
  2285. /*    zp = tzname[bp->tm_isdst];*/
  2286. /*    sprintf(buf, "%s%s %.16s %.3s %.5s", from, tp, zp, tp+20);*/
  2287.     sprintf(buf, "From %s %.16s %.4s", from, tp, tp+20);
  2288.  
  2289. #ifdef UGLYUUCP
  2290.     if (!local){
  2291.             strcat(buf," remote from ");
  2292.             strcat(buf,Myname);
  2293.            }
  2294. #endif
  2295.     strcat(buf,"\n");
  2296.     write(outto->_file,buf,strlen(buf));
  2297.     fflush(outto);
  2298.  
  2299.     if (fgets(buf,sizeof(buf),into) != NULL)
  2300.     if((strncmp(&buf[0], "From ", 5) == 0 || strncmp(&buf[0], "From:", 5) == 0))
  2301.          write(outto->_file,">",1);
  2302.     
  2303.     write(outto->_file,buf,strlen(buf));
  2304. }
  2305.  
  2306.  
  2307. /* attempt to return dead letter */
  2308. /* we'll do better on this one next time */
  2309.  
  2310. deadletter(retlet, here)
  2311. FILE *retlet;
  2312. int here;
  2313. {
  2314.     if(getlogin() != NULL) syserr("Letter failed....\n");
  2315. }
  2316.  
  2317. /* go here on a signal we want to catch */
  2318. intsig()
  2319. {
  2320.     unlink(templet);
  2321.     exit(EX_OK);
  2322. }
  2323.  
  2324. /* put command strings in the logfile */
  2325.  
  2326. #ifdef LOG
  2327.  
  2328. maillog(command)
  2329. char * command;
  2330. {
  2331.     FILE *f;
  2332.     char atime[24];
  2333.     long clock;
  2334.     time (&clock);
  2335.     strncpy(atime,ctime(&clock),24);
  2336.  
  2337.     if ((f=fopen(logfile,"a")) != NULL)
  2338.         {
  2339.             fprintf(f,"%s: %s - %s\n",progname,atime,command);
  2340.             fclose(f);
  2341.         }
  2342. }
  2343.  
  2344. #endif
  2345. SHAR_EOF
  2346. if test 12804 -ne "`wc -c < 'uumail.c'`"
  2347. then
  2348.     echo shar: error transmitting "'uumail.c'" '(should have been 12804 characters)'
  2349. fi
  2350. fi
  2351. echo shar: extracting "'uupath.1'" '(759 characters)'
  2352. if test -f 'uupath.1'
  2353. then
  2354.     echo shar: will not over-write existing file "'uupath.1'"
  2355. else
  2356. cat << \SHAR_EOF > 'uupath.1'
  2357. .TH "UUPATH" "1" "Baylor College of Medicine"
  2358. .fi
  2359. .ad b
  2360. .SH NAME
  2361. uupath \- print mail routing information using uucpmap database
  2362. .SH SYNOPSIS
  2363. .B uupath  \fIhost1 host2 host3 ...\fR
  2364. .SH DESCRIPTION
  2365. .B Uupath
  2366. is designed to be used to query the uucpmap database for mail routing
  2367. paths used by
  2368. .I uumail.
  2369. .SS Arguments
  2370. .IP "host1 host2 host3 ..."
  2371. where host1, host2, host3 and so on are system node names on the network.
  2372. Many hostnames may be entered as arguements to
  2373. .I uupath.
  2374.  
  2375. .SH FILES
  2376. .IP "/usr/lib/uucp/palias" 
  2377. Path file produced by pathalias.
  2378. .SH "SEE ALSO"
  2379. pathalias(1), Pnews(1), Rnmail(1), rn(1), postnews(1), readnews(1), uumail(8)
  2380.  
  2381. .SH AUTHORS
  2382. .br
  2383. Jeff Donnelly, University of Illinois
  2384. .br
  2385. Stan Barber, Baylor College of Medicine & Rice University
  2386.  
  2387. SHAR_EOF
  2388. if test 759 -ne "`wc -c < 'uupath.1'`"
  2389. then
  2390.     echo shar: error transmitting "'uupath.1'" '(should have been 759 characters)'
  2391. fi
  2392. fi
  2393. echo shar: extracting "'uupath.c'" '(1155 characters)'
  2394. if test -f 'uupath.c'
  2395. then
  2396.     echo shar: will not over-write existing file "'uupath.c'"
  2397. else
  2398. cat << \SHAR_EOF > 'uupath.c'
  2399. /*
  2400.  * Name: uupath
  2401.  *
  2402.  * Calls getpath to lookup the usenet path
  2403.  *
  2404.  * Author: J. Donnelly  3/82
  2405.  * $Log:    uupath.c,v $
  2406.  * Revision 1.3  85/08/03  01:26:17  UUCP
  2407.  * *** empty log message ***
  2408.  * 
  2409.  * Revision 1.2  85/07/19  17:47:05  UUCP
  2410.  * updated to define Debug for compatability with getpath
  2411.  * 
  2412.  * Revision 1.1  85/07/11  18:35:59  sob
  2413.  * Initial revision
  2414.  * 
  2415.  *
  2416.  */
  2417.  
  2418. #include    "uuconf.h"
  2419. bool Debug;
  2420.  
  2421. static char rcsid[] = "$Header: uupath.c,v 1.3 85/08/03 01:26:17 UUCP Exp $";
  2422.  
  2423. main (argc, argv) char *argv[];
  2424. {
  2425.     char    path[PATHSIZ],work[BUFSIZ];
  2426.     int     i,
  2427.             retval;                    /* value returned from getpath */
  2428.  
  2429.     if (argc < 2)
  2430.     {
  2431.     printf ("Usage: uupath sysname1 sysname2 ...\n");
  2432.     exit (EX_USAGE);
  2433.     }
  2434.  
  2435.     for (i = 1; i < argc; i++)
  2436.     {
  2437.     retval = getpath (argv[i], &path[0],DATABASE);        /* lookup usenet path */
  2438.     if (retval == EX_NOHOST)
  2439.         printf ("Can't find path to %s\n", argv[i]);
  2440.  
  2441.     else
  2442.         if (retval == EX_NOINPUT)
  2443.         {
  2444.         printf ("Can't open the network map\n");
  2445.         exit (EX_TEMPFAIL);
  2446.         }
  2447.  
  2448.         else
  2449.         {
  2450.         sprintf (&work[0],"Path to %s:  %s\n", argv[i], &path[0]);
  2451.             printf(&work[0],"username");
  2452.         }
  2453.     }
  2454. }
  2455. SHAR_EOF
  2456. if test 1155 -ne "`wc -c < 'uupath.c'`"
  2457. then
  2458.     echo shar: error transmitting "'uupath.c'" '(should have been 1155 characters)'
  2459. fi
  2460. fi
  2461. exit 0
  2462. #    End of shell archive
  2463.